home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / threads / thread.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  20KB  |  860 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 18 "thread.d"
  17. #include <string.h> 
  18.  
  19. #ifndef unix 
  20. #include <conio.h> 
  21. #else 
  22. int getch(void); 
  23. int kbhit(void); 
  24. #endif 
  25.  
  26.  
  27. typedef struct _priority_queue *PQ; 
  28.  
  29. #define    CLASS    Thread_c
  30. #define    ivType    Thread_iv_t
  31.  
  32. #include "generics.h"
  33.  
  34. object    Thread_c;
  35.  
  36.  
  37. #line 38 "thread.c"
  38. typedef struct  _Thread_iv_t  {
  39.     object iObj;
  40.     char * iName;
  41.     int ( * iFun ) ( void * );
  42.     jmp_buf iRtn;
  43.     char * iStack_buf;
  44.     char * iStack_location;
  45.     int iStack_buf_size;
  46.     int iStack_size;
  47.     int iState;
  48.     int iAutoDispose;
  49.     int iPriority;
  50.     void * iArg;
  51.     int iPrev_state;
  52.     int iHold_count;
  53.     int iRtnVal;
  54.     int iWr;
  55.     object iWait;
  56.     struct _Thread_iv_t * iTwait;
  57.     struct _Thread_iv_t * iNext , * iPrev;
  58.     object iSema;
  59. }    Thread_iv_t;
  60.  
  61.  
  62. #line 63 "thread.c"
  63. typedef struct  _Thread_cv_t  {
  64.     char * cTs_stkpos;
  65.     PQ cMpq;
  66.     PQ cCpq;
  67.     ivType * cCt;
  68.     ivType * cTnr;
  69.     ivType * cGkt;
  70.     PQ cFpql;
  71.     object cThreads;
  72.     unsigned long cThrno;
  73. }    Thread_cv_t;
  74.  
  75. static    Thread_cv_t    *Thread_cv;
  76.  
  77.  
  78. #line 76 "thread.d"
  79. struct _priority_queue { 
  80.     int priority; 
  81.     ivType *thread; 
  82.     PQ next; 
  83. }; 
  84.  
  85.  
  86.  
  87. jmp_buf _t_start; 
  88.  
  89.  
  90.  
  91. #define STACKINC 100 
  92.  
  93.  
  94.  
  95. #define NTICKS 1 
  96.  
  97. static objrtn Release(object self, int yld); 
  98.  
  99. #ifdef FUNCTIONS 
  100.  
  101. #define NEXT_THREAD next_thread() 
  102.  
  103. static void next_thread(void); 
  104. static void add_tnr(ivType *t); 
  105. static void del_tnr(ivType *t); 
  106.  
  107. #else 
  108.  
  109. #line 116 "thread.d"
  110. #define NEXT_THREAD if (Thread_cv->cCpq) Thread_cv->cCpq->thread = Thread_cv->cCpq->thread->iNext; if (Thread_cv->cGkt && kbhit()) { Release(Thread_cv->cGkt->iObj, 0); Thread_cv->cGkt = NULL; } if (Thread_cv->cCpq = Thread_cv->cMpq) Thread_cv->cCt = Thread_cv->cCpq->thread; else exit(0) 
  111.  
  112. #line 122 "thread.d"
  113. #define add_tnr(t) if (t->iNext = Thread_cv->cTnr) Thread_cv->cTnr->iPrev = t; t->iPrev = NULL; Thread_cv->cTnr = t 
  114.  
  115. #line 130 "thread.d"
  116. #define del_tnr(t) if (t->iPrev) t->iPrev->iNext = t->iNext; else Thread_cv->cTnr = t->iNext; if (t->iNext) t->iNext->iPrev = t->iPrev 
  117.  
  118. #endif 
  119.  
  120. extern void _start_timer(void); 
  121.  
  122.  
  123. static void start_thread(ivType *s); 
  124. static void stop_thread(ivType *t); 
  125. static void resolve_waits(ivType *t); 
  126. static void delete_wait(ivType *t); 
  127. static PQ new_pq(void); 
  128. static void free_pq(PQ t); 
  129. static void delete_sema_waits(ivType *t); 
  130. static void _dynace_yield(void); 
  131. static char *strsave(char *); 
  132.  
  133. #ifdef FUNCTIONS 
  134.  
  135. static void next_thread(void) 
  136. { 
  137.     if (Thread_cv->cCpq) 
  138.         Thread_cv->cCpq->thread = Thread_cv->cCpq->thread->iNext; 
  139.     if (Thread_cv->cGkt && kbhit()) { 
  140.         Release(Thread_cv->cGkt->iObj, 0); 
  141.         Thread_cv->cGkt = NULL; 
  142.     } 
  143.     if (Thread_cv->cCpq = Thread_cv->cMpq) 
  144.         Thread_cv->cCt = Thread_cv->cCpq->thread; 
  145.     else 
  146.         exit(0); 
  147. } 
  148.  
  149. #endif 
  150.  
  151.  
  152.  
  153.  
  154. static void start_thread(ivType *s) 
  155. { 
  156.     PQ tpq, ppq, npq; 
  157.  
  158.     for (ppq=NULL, tpq=Thread_cv->cMpq ; tpq && s->iPriority < tpq->priority ; ppq=tpq, tpq=tpq->next); 
  159.     if (!tpq || s->iPriority != tpq->priority) { 
  160.         npq = new_pq(); 
  161.         s->iNext = s->iPrev = s; 
  162.         npq->priority = s->iPriority; 
  163.         npq->thread = s; 
  164.         npq->next = tpq; 
  165.         if (ppq) 
  166.             ppq->next = npq; 
  167.         else 
  168.             Thread_cv->cMpq = npq; 
  169.     } else 
  170.         if (tpq == Thread_cv->cCpq) { 
  171.         s->iNext = tpq->thread->iNext; 
  172.         s->iPrev = tpq->thread; 
  173.         tpq->thread->iNext = s; 
  174.         s->iNext->iPrev = s; 
  175.     } else { 
  176.         s->iNext = tpq->thread; 
  177.         s->iPrev = tpq->thread->iPrev; 
  178.         tpq->thread->iPrev = s; 
  179.         s->iPrev->iNext = s; 
  180.         tpq->thread = s; 
  181.     } 
  182. } 
  183.  
  184.  
  185.  
  186. static void stop_thread(ivType *t) 
  187. { 
  188.     PQ pq, ppq; 
  189.  
  190.     for (ppq=NULL, pq=Thread_cv->cMpq ; pq && pq->priority != t->iPriority ; 
  191.     ppq=pq, pq=pq->next); 
  192.     if (!pq) 
  193.         goto error; 
  194.     if (t->iNext != t) { 
  195.         t->iPrev->iNext = t->iNext; 
  196.         t->iNext->iPrev = t->iPrev; 
  197.         if (pq->thread == t) { 
  198.             pq->thread = t->iNext; 
  199.             if (pq == Thread_cv->cCpq) 
  200.                 Thread_cv->cCpq = NULL; 
  201.         } 
  202.     } else { 
  203.         if (pq->thread != t) 
  204.             goto error; 
  205.         if (pq == Thread_cv->cCpq) 
  206.             Thread_cv->cCpq = NULL; 
  207.         if (ppq) 
  208.             ppq->next = pq->next; 
  209.         else 
  210.             Thread_cv->cMpq = pq->next; 
  211.         free_pq(pq); 
  212.     } 
  213.     return; 
  214.     error: 
  215.     fprintf(stderr, "Bad priority queue\n"); 
  216.     exit(1); 
  217. } 
  218.  
  219. #ifdef FUNCTIONS 
  220.  
  221.  
  222.  
  223. static void add_tnr(ivType *t) 
  224. { 
  225.     if (t->iNext = Thread_cv->cTnr) 
  226.         Thread_cv->cTnr->iPrev = t; 
  227.     t->iPrev = NULL; 
  228.     Thread_cv->cTnr = t; 
  229. } 
  230.  
  231.  
  232.  
  233. static void del_tnr(ivType *t) 
  234. { 
  235.     if (t->iPrev) 
  236.         t->iPrev->iNext = t->iNext; 
  237.     else 
  238.         Thread_cv->cTnr = t->iNext; 
  239.     if (t->iNext) 
  240.         t->iNext->iPrev = t->iPrev; 
  241. } 
  242.  
  243. #endif 
  244.  
  245. imeth objrtn Kill(object self, int rtn)
  246. { Thread_iv_t *iv = GetIVs(Thread, self);
  247.     if (iv->iState == DONE_THREAD) 
  248.         return self; 
  249.     INHIBIT_THREADER; 
  250.     iv->iRtnVal = rtn; 
  251.     if (iv->iStack_buf) { 
  252.         free(iv->iStack_buf); 
  253.         iv->iStack_buf = NULL; 
  254.         iv->iStack_buf_size = iv->iStack_size = 0; 
  255.     } 
  256.     if (iv->iState == NEW_THREAD || iv->iState == RUNNING_THREAD) { 
  257.         stop_thread(iv); 
  258.         add_tnr(iv); 
  259.     } else if (iv->iState == WAITING_FOR_THREAD) 
  260.         delete_wait(iv); 
  261.     iv->iState = DONE_THREAD; 
  262.     if (iv->iSema) 
  263.         delete_sema_waits(iv); 
  264.     if (iv->iWait) 
  265.         resolve_waits(iv); 
  266.     if (iv == Thread_cv->cGkt) 
  267.         Thread_cv->cGkt = NULL; 
  268. #if 0 
  269.         if (iKmrp) { 
  270.         static gRemoveRegisteredMemory_t rrm = NULL; 
  271.  
  272.         if (!rrm) 
  273.             rrm = cmcPointer(Dynace, gRemoveRegisteredMemory); 
  274.         (rrm)(Dynace, iKmrp); 
  275.         iKmrp = NULL; 
  276.     } 
  277. #endif 
  278.         ENABLE_THREADER; 
  279.     if (!Thread_cv->cCpq || Thread_cv->cCt == iv) { 
  280.         Thread_cv->cCt = NULL; 
  281.         _dynace_yield(); 
  282.     } 
  283.     return self; 
  284. } 
  285.  
  286. imeth objrtn Dispose(object self)
  287. { Thread_iv_t *iv = GetIVs(Thread, self);
  288.     INHIBIT_THREADER; 
  289.     if (iv->iStack_buf) 
  290.         free(iv->iStack_buf); 
  291.     if (iv->iState == NEW_THREAD || iv->iState == RUNNING_THREAD) 
  292.         stop_thread(iv); 
  293.     else { 
  294.         if (iv->iState == WAITING_FOR_THREAD) 
  295.             delete_wait(iv); 
  296.         del_tnr(iv); 
  297.     } 
  298.  
  299.     iv->iState = DONE_THREAD; 
  300.     if (iv->iSema) 
  301.         delete_sema_waits(iv); 
  302.     if (iv->iWait) { 
  303.         static gDispose_t dispose = NULL; 
  304.  
  305.         if (!dispose) 
  306.             dispose = imcPointer(LinkObject, gDispose); 
  307.         resolve_waits(iv); 
  308.         (*dispose)(iv->iWait); 
  309.     } 
  310.     if (iv == Thread_cv->cGkt) 
  311.         Thread_cv->cGkt = NULL; 
  312. #if 0 
  313.         if (iKmrp) { 
  314.         static gRemoveRegisteredMemory_t rrm = NULL; 
  315.  
  316.         if (!rrm) 
  317.             rrm = cmcPointer(Dynace, gRemoveRegisteredMemory); 
  318.         (*rrm)(Dynace, iKmrp); 
  319.     } 
  320. #endif 
  321.         gRemoveStr(Thread_cv->cThreads, iv->iName); 
  322.     free(iv->iName); 
  323.     oSuper(Thread_c, gDispose, self)(self); 
  324.     ENABLE_THREADER; 
  325.     if (!Thread_cv->cCpq || Thread_cv->cCt == iv) { 
  326.         Thread_cv->cCt = NULL; 
  327.         _dynace_yield(); 
  328.     } 
  329.     return NULL; 
  330. } 
  331.  
  332. static char *strsave(char *s) 
  333. { 
  334.     char *p = Tnalloc(char, strlen(s)+1); 
  335.     strcpy(p, s); 
  336.     return p; 
  337. } 
  338.  
  339. cmeth objrtn Thread_cm_gNew(object self)
  340. { 
  341.     return gShouldNotImplement(self, "gNew"); 
  342. } 
  343.  
  344. cmeth objrtn Thread_cm_gNewThread(object self, char *name, ifun fun, int priority, void *arg, int run, int autoDispose)
  345. { 
  346.     char buf[30]; 
  347.     object obj = oSuper(Thread_c, gNew, self)(self); 
  348.     ivType *iv = ivPtr(obj); 
  349.     static gFindStr_t find = NULL; 
  350.     static gAddStr_t add = NULL; 
  351.  
  352.     INHIBIT_THREADER; 
  353.     iv->iObj = obj; 
  354.     if (name) 
  355.         iv->iName = strsave(name); 
  356.     else { 
  357.         sprintf(buf, "unnamed-%ld", ++Thread_cv->cThrno); 
  358.         iv->iName = strsave(buf); 
  359.     } 
  360.     if (!find) 
  361.         find = imcPointer(StringDictionary, gFindStr); 
  362.     if ((*find)(Thread_cv->cThreads, iv->iName)) { 
  363.         free(iv->iName); 
  364.         oSuper(Thread_c, gDispose, self)(self); 
  365.         ENABLE_THREADER; 
  366.         return NULL; 
  367.     } 
  368.  
  369.     iv->iFun = (int (*)(void *)) fun; 
  370.     iv->iPriority = priority; 
  371.     iv->iArg = arg; 
  372.     iv->iAutoDispose = autoDispose; 
  373.  
  374.     if (!add) 
  375.         add = imcPointer(StringDictionary, gAddStr); 
  376.     (*add)(Thread_cv->cThreads, iv->iName, obj); 
  377.     ENABLE_THREADER; 
  378.  
  379.     if (run) { 
  380.         iv->iState = NEW_THREAD; 
  381.         start_thread(iv); 
  382.         if (Thread_cv->cCt && Thread_cv->cCt->iPriority < priority) 
  383.             _dynace_yield(); 
  384.     } else { 
  385.         iv->iPrev_state = NEW_THREAD; 
  386.         iv->iState = HOLD_THREAD; 
  387.         iv->iHold_count = 1; 
  388.         add_tnr(iv); 
  389.     } 
  390.  
  391.     return obj; 
  392. } 
  393.  
  394. void _start_threader(char *stkpos) 
  395. { 
  396.     object t; 
  397.  
  398.     Thread; 
  399.     if (Thread_cv->cMpq) 
  400.         return; 
  401.  
  402.     INHIBIT_THREADER; 
  403.     t = gNewThread(CLASS, "main", NULL, DEFAULT_PRIORITY, NULL, 1, 0); 
  404.     ENABLE_THREADER; 
  405.     Thread_cv->cCt = ivPtr(t); 
  406.  
  407.     Thread_cv->cCt->iState = RUNNING_THREAD; 
  408.     Thread_cv->cCpq = Thread_cv->cMpq; 
  409.  
  410.     Thread_cv->cTs_stkpos = stkpos; 
  411.  
  412.     _start_timer(); 
  413. } 
  414.  
  415. void _start_thread(void) 
  416. { 
  417.     Thread_cv->cCt->iState = RUNNING_THREAD; 
  418.     _tick_count = NTICKS; 
  419.     Thread_cv->cCt->iRtnVal = (*Thread_cv->cCt->iFun)(Thread_cv->cCt->iArg); 
  420.     Kill(Thread_cv->cCt->iObj, Thread_cv->cCt->iRtnVal); 
  421.     if (Thread_cv->cCt->iAutoDispose) 
  422.         Dispose(Thread_cv->cCt->iObj); 
  423. } 
  424.  
  425. imeth objrtn Hold(object self)
  426. { Thread_iv_t *iv = GetIVs(Thread, self);
  427.     if (iv->iState == DONE_THREAD) 
  428.         return self; 
  429.     if (iv->iState == HOLD_THREAD) { 
  430.         iv->iHold_count++; 
  431.         return self; 
  432.     } 
  433.     if (iv->iState == NEW_THREAD || iv->iState == RUNNING_THREAD) { 
  434.         stop_thread(iv); 
  435.         add_tnr(iv); 
  436.     } 
  437.     iv->iPrev_state = iv->iState; 
  438.     iv->iState = HOLD_THREAD; 
  439.     iv->iHold_count = 1; 
  440.     if (iv == Thread_cv->cCt) 
  441.         _dynace_yield(); 
  442.     return self; 
  443. } 
  444.  
  445. imeth objrtn Release(object self, int yld)
  446. { Thread_iv_t *iv = GetIVs(Thread, self);
  447.     if (iv->iState == HOLD_THREAD && !--iv->iHold_count) { 
  448.         iv->iState = iv->iPrev_state; 
  449.         if (iv->iState == NEW_THREAD || iv->iState == RUNNING_THREAD) { 
  450.             del_tnr(iv); 
  451.             start_thread(iv); 
  452.             if (yld && iv->iPriority > Thread_cv->cCt->iPriority) 
  453.                 _dynace_yield(); 
  454.         } 
  455.     } 
  456.     return self; 
  457. } 
  458.  
  459. static void _dynace_yield(void) 
  460. { 
  461.     ivType *t; 
  462.  
  463.  
  464.  
  465.     if (Thread_cv->cCt && Thread_cv->cCt->iState != DONE_THREAD) { 
  466. #ifdef sparc 
  467.  
  468.         Thread_cv->cCt->iStack_location = (char *) &t - 0x80; 
  469. #else 
  470.         Thread_cv->cCt->iStack_location = (char *) &t; 
  471. #endif 
  472.         if ((Thread_cv->cCt->iStack_size = Thread_cv->cTs_stkpos - Thread_cv->cCt->iStack_location) < 0) 
  473.             Thread_cv->cCt->iStack_size = 0; 
  474.         if (Thread_cv->cCt->iStack_size > Thread_cv->cCt->iStack_buf_size) { 
  475.             Thread_cv->cCt->iStack_buf_size = ((Thread_cv->cCt->iStack_size / STACKINC) + 1) * STACKINC; 
  476.             if (Thread_cv->cCt->iStack_buf) 
  477.                 Thread_cv->cCt->iStack_buf = Tnrealloc(char, Thread_cv->cCt->iStack_buf_size, Thread_cv->cCt->iStack_buf); 
  478.             else 
  479.                 Thread_cv->cCt->iStack_buf = Tnalloc(char, Thread_cv->cCt->iStack_buf_size); 
  480. #if 0 
  481.             { 
  482.                 static gChangeRegisteredMemory_t crm=NULL; 
  483.                 static gRegisterMemory_t rm; 
  484.  
  485.                 if (!crm) { 
  486.                     INHIBIT_THREADER; 
  487.                     crm = cmcPointer(Dynace, gChangeRegisteredMemory); 
  488.                     rm = cmcPointer(Dynace, gRegisterMemory); 
  489.                     ENABLE_THREADER; 
  490.                 } 
  491.                 if (Thread_cv->cCt->iKmrp) 
  492.                     (*crm)(Dynace, Thread_cv->cCt->iKmrp, Thread_cv->cCt->iStack_buf, (long) Thread_cv->cCt->iStack_buf_size); 
  493.                 else 
  494.                     Thread_cv->cCt->iKmrp = (void *)(*rm)(Dynace, Thread_cv->cCt->iStack_buf, (long) Thread_cv->cCt->iStack_buf_size); 
  495.             } 
  496. #endif 
  497.         } 
  498.         if (Thread_cv->cCt->iStack_size) { 
  499. #ifdef sparc 
  500.             asm("t 3"); 
  501. #endif 
  502.             memcpy(Thread_cv->cCt->iStack_buf, Thread_cv->cCt->iStack_location, Thread_cv->cCt->iStack_size); 
  503.         } 
  504.  
  505.  
  506.  
  507.         if (setjmp(Thread_cv->cCt->iRtn)) { 
  508.  
  509.  
  510.  
  511.             if (Thread_cv->cCt->iStack_size) 
  512.                 memcpy(Thread_cv->cCt->iStack_location, Thread_cv->cCt->iStack_buf, Thread_cv->cCt->iStack_size); 
  513.             _tick_count = NTICKS; 
  514.             return; 
  515.         } 
  516.     } 
  517.  
  518.  
  519.  
  520.     NEXT_THREAD; 
  521.  
  522.     if (Thread_cv->cCt->iState == NEW_THREAD) 
  523.         longjmp(_t_start, 1); 
  524.     else { 
  525. #ifdef sparc 
  526.         if (Thread_cv->cCt->iStack_size){ 
  527.             asm("t 3"); 
  528.             memcpy(Thread_cv->cCt->iStack_location, Thread_cv->cCt->iStack_buf, Thread_cv->cCt->iStack_size); 
  529.         } 
  530. #endif 
  531.         longjmp(Thread_cv->cCt->iRtn, 1); 
  532.     } 
  533. } 
  534.  
  535. cmeth objrtn Thread_cm_gFindStr(object self, char *name)
  536. { 
  537.     USE(self); 
  538.     return name ? gFindValueStr(Thread_cv->cThreads, name) : (Thread_cv->cCt ? Thread_cv->cCt->iObj : (object) NULL); 
  539. #if 0 
  540.     ivType *t, *s; 
  541.     PQ pq; 
  542.  
  543.     if (!name) 
  544.         return Thread_cv->cCt ? Thread_cv->cCt->iObj : NULL; 
  545.     for (pq=Thread_cv->cMpq ; pq ; pq=pq->next) { 
  546.         s = t = pq->thread; 
  547.         do { 
  548.             if (t->iName && !strcmp(t->iName, name)) 
  549.                 return t->iObj; 
  550.             t = t->iNext; 
  551.         } while (t != s); 
  552.     } 
  553.     for (t=Thread_cv->cTnr ; t ; t=t->iNext) 
  554.         if (t->iName && !strcmp(t->iName, name)) 
  555.         return t->iObj; 
  556.     return NULL; 
  557. #endif 
  558. } 
  559.  
  560. imeth int Thread_im_gIntValue(object self)
  561. { Thread_iv_t *iv = GetIVs(Thread, self);
  562.     return iv->iRtnVal; 
  563. } 
  564.  
  565. imeth int Thread_im_gState(object self)
  566. { Thread_iv_t *iv = GetIVs(Thread, self);
  567.     return iv->iState; 
  568. } 
  569.  
  570. imeth char * Thread_im_gName(object self)
  571. { Thread_iv_t *iv = GetIVs(Thread, self);
  572.     return iv->iName; 
  573. } 
  574.  
  575. imeth int Thread_im_gPriority(object self)
  576. { Thread_iv_t *iv = GetIVs(Thread, self);
  577.     return iv->iPriority; 
  578. } 
  579.  
  580. imeth objrtn Thread_im_gChangePriority(object self, int p)
  581. { Thread_iv_t *iv = GetIVs(Thread, self);
  582.     int f, oldp; 
  583.  
  584.     oldp = iv->iPriority; 
  585.     if (f = iv->iState == NEW_THREAD || iv->iState == RUNNING_THREAD) 
  586.         stop_thread(iv); 
  587.     iv->iPriority = p; 
  588.     if (f) 
  589.         start_thread(iv); 
  590.     if (Thread_cv->cCt == iv && p < oldp && Thread_cv->cMpq->thread->iPriority > p || 
  591.         Thread_cv->cCt != iv && f && p > Thread_cv->cCt->iPriority) 
  592.         _dynace_yield(); 
  593.     return self; 
  594. } 
  595.  
  596. imeth int Thread_im_gWaitFor(object self)
  597. { Thread_iv_t *iv = GetIVs(Thread, self);
  598.     if (iv == Thread_cv->cCt) 
  599.         return 0; 
  600.     if (iv->iState != DONE_THREAD) { 
  601.         stop_thread(Thread_cv->cCt); 
  602.         add_tnr(Thread_cv->cCt); 
  603.  
  604.         INHIBIT_THREADER; 
  605.         if (!iv->iWait) 
  606.             iv->iWait = gNew(LinkObject); 
  607.         gAddFirst(iv->iWait, Thread_cv->cCt->iObj); 
  608.         ENABLE_THREADER; 
  609.  
  610.         Thread_cv->cCt->iTwait = iv; 
  611.         Thread_cv->cCt->iState = WAITING_FOR_THREAD; 
  612.         _dynace_yield(); 
  613.         return Thread_cv->cCt->iWr; 
  614.     } else 
  615.         return iv->iRtnVal; 
  616. } 
  617.  
  618.  
  619.  
  620. static void resolve_waits(ivType *t) 
  621. { 
  622.     object thread; 
  623.     static gFirst_t first=NULL; 
  624.     static gDisposeFirst_t disposeFirst; 
  625.  
  626.     if (!t->iWait) 
  627.         return; 
  628.     INHIBIT_THREADER; 
  629.     if (!first) { 
  630.         first = imcPointer(LinkObject, gFirst); 
  631.         disposeFirst = imcPointer(LinkObject, gDisposeFirst); 
  632.     } 
  633.     while (thread = (*first)(t->iWait)) { 
  634.         ivType *tt; 
  635.  
  636.         tt = ivPtr(thread); 
  637.         tt->iState = RUNNING_THREAD; 
  638.         del_tnr(tt); 
  639.         start_thread(tt); 
  640.         tt->iWr = t->iRtnVal; 
  641.         t->iTwait = NULL; 
  642.         (*disposeFirst)(t->iWait); 
  643.     } 
  644.     ENABLE_THREADER; 
  645. } 
  646.  
  647.  
  648.  
  649.  
  650. static void delete_wait(ivType *t) 
  651. { 
  652.     object linkSequence, linkValue, thread; 
  653.     static gDispose_t disposeNode, dispose; 
  654.     static gValue_t value; 
  655.     static gNext_t next; 
  656.     static gSequenceLinks_t sequenceLinks = NULL; 
  657.  
  658.     if (!t->iTwait->iWait) 
  659.         return; 
  660.     INHIBIT_THREADER; 
  661.     if (!sequenceLinks) { 
  662.         sequenceLinks = imcPointer(LinkObject, gSequenceLinks); 
  663.         next = imcPointer(LinkSequence, gNext); 
  664.         value = imcPointer(LinkValue, gValue); 
  665.         disposeNode = imcPointer(LinkValue, gDispose); 
  666.         dispose = imcPointer(LinkSequence, gDispose); 
  667.     } 
  668.     linkSequence = (*sequenceLinks)(t->iTwait->iWait); 
  669.     while (linkValue = (*next)(linkSequence)) { 
  670.         thread = (*value)(linkValue); 
  671.         if (thread == t->iObj) { 
  672.             (*disposeNode)(linkValue); 
  673.             break; 
  674.         } 
  675.     } 
  676.     if (linkValue) 
  677.         (*dispose)(linkSequence); 
  678.     ENABLE_THREADER; 
  679. } 
  680.  
  681. static PQ new_pq(void) 
  682. { 
  683.     PQ t; 
  684.  
  685.     if (Thread_cv->cFpql) { 
  686.         t = Thread_cv->cFpql; 
  687.         Thread_cv->cFpql = t->next; 
  688.         memset(t, 0, sizeof(*t)); 
  689.     } else 
  690.         t = Tcalloc(struct _priority_queue); 
  691.     return(t); 
  692. } 
  693.  
  694. static void free_pq(PQ t) 
  695. { 
  696.     t->next = Thread_cv->cFpql; 
  697.     Thread_cv->cFpql = t; 
  698. } 
  699.  
  700. static void delete_sema_waits(ivType *t) 
  701. { 
  702.     static gRemoveWaits_t removeWaits = NULL; 
  703.  
  704.     INHIBIT_THREADER; 
  705.     if (!removeWaits) 
  706.         removeWaits = imiPointer(t->iSema, gRemoveWaits); 
  707.     (*removeWaits)(t->iSema, t->iObj); 
  708.     t->iSema = NULL; 
  709.     ENABLE_THREADER; 
  710. } 
  711.  
  712. cmeth int Thread_cm_gBlockingGetkey(object self)
  713. { 
  714.     USE(self); 
  715.     if (Thread_cv->cGkt) 
  716.         return -1; 
  717.     if (!kbhit()) { 
  718.         Thread_cv->cGkt = Thread_cv->cCt; 
  719.         Hold(Thread_cv->cCt->iObj); 
  720.     } 
  721.     return getch(); 
  722. } 
  723.  
  724.  
  725.  
  726. imeth objrtn Thread_im_gReleaseSemaphore(object self)
  727. { Thread_iv_t *iv = GetIVs(Thread, self);
  728.     if (iv->iState == WAITING_FOR_SEMAPHORE) { 
  729.         iv->iState = RUNNING_THREAD; 
  730.         del_tnr(iv); 
  731.         start_thread(iv); 
  732.     } else if (iv->iState == HOLD_THREAD && iv->iPrev_state == WAITING_FOR_SEMAPHORE) 
  733.         iv->iPrev_state = RUNNING_THREAD; 
  734.     iv->iSema = NULL; 
  735.     return self; 
  736. } 
  737.  
  738.  
  739.  
  740. imeth objrtn Thread_im_gWaitSemaphore(object self, object sema)
  741. { Thread_iv_t *iv = GetIVs(Thread, self);
  742.     stop_thread(iv); 
  743.     add_tnr(iv); 
  744.     iv->iState = WAITING_FOR_SEMAPHORE; 
  745.     iv->iSema = sema; 
  746.     return self; 
  747. } 
  748.  
  749. static objrtn MarkThreadStacks(object self) 
  750. { 
  751.     ivType *t, *s; 
  752.     PQ pq; 
  753.     static gMarkRange_t markRange = NULL; 
  754.  
  755.     if (!markRange) 
  756.         markRange = cmcPointer(Dynace, gMarkRange); 
  757.  
  758.     for (pq=Thread_cv->cMpq ; pq ; pq=pq->next) { 
  759.         s = t = pq->thread; 
  760.         do { 
  761.             if (t->iStack_buf && t->iStack_size) 
  762.                 (*markRange)(Dynace, (char _HUGE **)t->iStack_buf, (char _HUGE **)(t->iStack_buf + t->iStack_size)); 
  763.             t = t->iNext; 
  764.         } while (t != s); 
  765.     } 
  766.     for (t=Thread_cv->cTnr ; t ; t=t->iNext) 
  767.         if (t->iStack_buf && t->iStack_size) 
  768.         (*markRange)(Dynace, (char _HUGE **) t->iStack_buf, (char _HUGE **)(t->iStack_buf + t->iStack_size)); 
  769.     return self; 
  770. } 
  771.  
  772. #ifdef unix 
  773.  
  774.  
  775.  
  776. int kbhit(void) 
  777. { 
  778.     return 0; 
  779. } 
  780.  
  781. int getch(void) 
  782. { 
  783.     return getchar(); 
  784. } 
  785.  
  786. #endif 
  787.  
  788. imeth objrtn Thread_im_gCopy(object self)
  789. { 
  790.     return gShouldNotImplement(self, "Copy/DeepCopy"); 
  791. } 
  792.  
  793. static void init_class(void) 
  794. { 
  795.  
  796.  
  797.  
  798.     __dynace_yield = _dynace_yield; 
  799.  
  800.     Thread_cv->cThreads = gNewWithInt(StringDictionary, 41); 
  801.  
  802.     gMarkingMethod(CLASS, (ofun) MarkThreadStacks); 
  803. } 
  804.  
  805. #line 806 "thread.c"
  806.  
  807. objrtn    Thread_initialize(void)
  808. {
  809.     static  CRITICALSECTION  cs;
  810.     static  int volatile once = 0;
  811.  
  812.     ENTERCRITICALSECTION(_CI_CS_);
  813.     if (!once) {
  814.         INITIALIZECRITICALSECTION(cs);
  815.         once = 1;
  816.     }
  817.     LEAVECRITICALSECTION(_CI_CS_);
  818.  
  819.     ENTERCRITICALSECTION(cs);
  820.  
  821.     if (Thread_c) {
  822.         LEAVECRITICALSECTION(cs);
  823.         return Thread_c;
  824.     }
  825.     INHIBIT_THREADER;
  826.     Thread_c = gNewClass(Class, "Thread", sizeof(Thread_iv_t), sizeof(Thread_cv_t), END);
  827.     cMethodFor(Thread, gNewThread, Thread_cm_gNewThread);
  828.     cMethodFor(Thread, gFindStr, Thread_cm_gFindStr);
  829.     cMethodFor(Thread, gBlockingGetkey, Thread_cm_gBlockingGetkey);
  830.     cMethodFor(Thread, gNew, Thread_cm_gNew);
  831.     iMethodFor(Thread, gChangePriority, Thread_im_gChangePriority);
  832.     iMethodFor(Thread, gIntValue, Thread_im_gIntValue);
  833.     iMethodFor(Thread, gState, Thread_im_gState);
  834.     iMethodFor(Thread, gWaitSemaphore, Thread_im_gWaitSemaphore);
  835.     iMethodFor(Thread, gPriority, Thread_im_gPriority);
  836.     iMethodFor(Thread, gHold, Hold);
  837.     iMethodFor(Thread, gRelease, Release);
  838.     iMethodFor(Thread, gDispose, Dispose);
  839.     iMethodFor(Thread, gName, Thread_im_gName);
  840.     iMethodFor(Thread, gKill, Kill);
  841.     iMethodFor(Thread, gReleaseSemaphore, Thread_im_gReleaseSemaphore);
  842.     iMethodFor(Thread, gCopy, Thread_im_gCopy);
  843.     iMethodFor(Thread, gDeepDispose, Dispose);
  844.     iMethodFor(Thread, gDeepCopy, Thread_im_gCopy);
  845.     iMethodFor(Thread, gWaitFor, Thread_im_gWaitFor);
  846.  
  847.     Thread_cv = GetCVs(Thread);
  848.  
  849.     init_class();
  850.  
  851.     ENABLE_THREADER;
  852.  
  853.     LEAVECRITICALSECTION(cs);
  854.  
  855.     return Thread_c;
  856. }
  857.  
  858.  
  859.  
  860.